Programming Ruby: The Pragmatic Programmers' Guide (Second Edition): Streams as the Foundation of Ruby I/O

In Ruby, Input/Output isn't just a set of commands; it is a sophisticated stream-based architecture. At the heart of this system lies the IO class, which serves as a bidirectional channel between your program and the external world. Whether you are interacting with a file, a network socket, or the user's terminal, Ruby treats them as generic streams.

1. The Bidirectional Bridge

An IO object is a unified abstraction. While the operating system sees distinct file descriptors for reading and writing (like in a pipe), Ruby encapsulates these into a single object. This allows for seamless data flow in both directions.

2. Kernel & Standard Filters

The Kernel module provides methods like gets and print. These are essentially filters that delegate to the global constants STDIN and STDOUT. This means your code can be redirected at the OS level to process files or network streams without changing a single line of logic.

$$\text{Stream} \rightarrow \text{Buffer} \rightarrow \text{Ruby Interpreter}$$

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

What is the primary role of the Ruby IO class?

To convert Ruby objects into JSON strings.

To act as a bidirectional channel between Ruby and external resources.

To manage CPU thread cycles.

To define the graphical user interface of an application.

QUESTION 2

Which Kernel method reads an entire stream into an array of lines?

gets

readline

readlines

read_all

✅ Correct!

Correct! readlines consumes the entire stream and returns an array where each element is a line.

❌ Incorrect

gets and readline only fetch a single line at a time.

QUESTION 3

What is the difference between print and puts?

print adds a newline; puts does not.

puts adds a record separator (newline) to the output; print does not.

puts is used for files; print is for the screen.

There is no difference; they are aliases.

✅ Correct!

Correct! puts is a line-oriented output method that ensures a trailing newline.

❌ Incorrect

Actually, it's the other way around: puts appends the newline.

QUESTION 4

Which constant represents the default standard input in Ruby?

$INPUT

STDIN

IO_IN

CONSOLE

✅ Correct!

Correct! STDIN is the global constant referring to the standard input IO object.

❌ Incorrect

STDIN is the standard Ruby constant for input streams.

QUESTION 5

What does the << operator do when used with an IO object like STDOUT?

It shifts bits to the left.

It pushes data into the output stream without adding newlines or separators.

It creates a new subprocess.

It closes the stream.

✅ Correct!

Correct! The shovel operator (<<) treats the IO object like a buffer, appending data directly.

❌ Incorrect

While << is a bit-shift operator for Integers, for IO objects it is the stream append operator.

Case Study: The Standard Filter Pattern

Applying IO Abstractions in CLI Tools

You are tasked with creating a CLI tool that transforms text. The tool should read lines from the standard input, prepend a timestamp to each line, and output them to standard output. This tool must work both interactively and when redirected from a file (e.g., `cat log.txt | ruby transform.rb`).

1. Why is the `gets` method suitable for this task regardless of whether the input is a keyboard or a file?

Solution:
Because `gets` is a Kernel method that defaults to reading from `STDIN`. In Ruby's stream architecture, `STDIN` is an `IO` object that abstracts the source; the program doesn't need to know if the underlying file descriptor points to a TTY or a disk file.

2. If you needed to output a single character to the stream without any formatting, which method would you use?

Solution:
The `putc` method is designed specifically for outputting a single character to the stream.

3. How does the `STDOUT << data` syntax differ from `puts data` in a multithreaded context based on the lesson principles?

Solution:
`puts` is non-atomic because it writes the data and then writes a newline as separate operations. Using `<<` also writes raw data, but one must be careful with interleaving; however, the primary difference is that `<<` does not automatically add formatting or newlines, providing raw stream access.